System and method for recovery from failure of a storage server in a distributed column chunk data store

ABSTRACT

An improved system and method for recovery from failure of a storage server in a distributed column chunk data store is provided. A distributed column chunk data store may be provided by multiple storage servers operably coupled to a network. A storage server provided may include a database engine for partitioning a data table into the column chunks for distributing across multiple storage servers, a storage shared memory for storing the column chunks during processing of semantic operations performed on the column chunks, and a storage services manager for striping column chunks of a partitioned data table across multiple storage servers. Any data table may be flexibly partitioned into column chunks using one or more columns with various partitioning methods. Storage servers may then fail and column chunks may be recreated from parity column chunks and redistributed among the remaining storage servers in the column chunk data store.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present invention is related to the following U.S. patentapplications, filed concurrently herewith and incorporated herein intheir entireties:

“System and Method for Updating Data in a Distributed Column Chunk DataStore,” Attorney Docket No. 1040;

“System and Method for Adding a Storage Server to a Distributed ColumnChunk Data Store,” Attorney Docket No. 1050;

“System and Method for Removing a Storage Server in a Distributed ColumnChunk Data Store,” Attorney Docket No. 1060;

“System for Query Processing of Column Chunks in a Distributed ColumnChunk Data Store,” Attorney Docket No. 1080;

“System of a Hierarchy of Servers for Query Processing of Column Chunksin a Distributed Column Chunk Data Store,” Attorney Docket No. 1090;

“Method for Query Processing of Column Chunks in a Distributed ColumnChunk Data Store,” Attorney Docket No. 1100;

“Method Using Query Processing Servers for Query Processing of ColumnChunks in a Distributed Column Chunk Data Store,” Attorney Docket No.1110; and

“Method Using a Hierarchy of Servers for Query Processing of ColumnChunks in a Distributed Column Chunk Data Store,” Attorney Docket No.1120.

The present invention is also related to the following copending U.S.patent applications filed Sep. 13, 2005, assigned to the assignee of thepresent invention, and hereby incorporated by reference in theirentireties:

“System for a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/226,606;

“Method for a Distributed Column Chunk Data Store,” U.S. patentapplication Ser. No. 11/226,667; and

“System and Method for Compression in a Distributed Column Chunk DataStore,” U.S. patent application Ser. No. 11/226,668.

FIELD OF THE INVENTION

The invention relates generally to computer systems, and moreparticularly to an improved system and method for recovery from failureof a storage server in a distributed column chunk data store.

BACKGROUND OF THE INVENTION

Distributed storage systems implemented either as a distributed databaseor a distributed file system fail to scale well for data mining andbusiness intelligence applications that may require fast and efficientretrieval and processing of large volumes of data. Distributed databasesfor large volumes of data, perhaps on the order of terabytes, may betraditionally implemented across several servers, each designed to hosta portion of a database and typically storing a particular table data.In some implementations, such a system may also store a horizontallypartitioned table of data on one or more servers. For instance, thetechnique known as horizontal partitioning may be used to store a subsetof rows of data in a table resident on a storage server. Queries forretrieving data from the distributed storage system may then beprocessed by retrieving rows of data having many associated columns ofdatum for which only one or few columns may be needed to process thequery. As a result, the storage and retrieval of data in these types ofsystems is inefficient, and consequently such systems do not scale wellfor handling terabytes of data.

Typical transaction processing systems using a distributed databaselikewise fail to scale well for data mining and business intelligenceapplications. Such systems may characteristically have slower processingspeed during a failed transaction. During transaction processing afailed transaction may become abandoned and the database may be rolledback to a state prior to the failed transaction. Such databaseimplementations prove inefficient for updating large data sets on theorder of gigabytes or terabytes.

Distributed file systems are also inadequate for storage and retrievalof data for data mining and business intelligence applications. First ofall, distributed file systems may only provide low-level storageprimitives for reading and writing data to a file. In general, suchsystems fail to establish any semantic relationships between data andfiles stored in the file system. Unsurprisingly, semantic operations fordata storage and retrieval such as redistributing data, replacingstorage, and dynamically adding additional storage are not available forsuch distributed file systems.

What is needed is a way for providing data storage, query processing andretrieval for large volumes of data perhaps in the order of hundreds ofterabytes for data warehousing, data mining and business intelligenceapplications. Any such system and method should allow the use of commonstorage components without requiring expensive fault-tolerant equipment.

SUMMARY OF THE INVENTION

Briefly, the present invention may provide a system and method forrecovery from failure of a storage server in a distributed column chunkdata store. A distributed column chunk data store may be provided bymultiple storage servers operably coupled to a network. A clientexecuting an application may also be operably coupled to the network. Astorage server provided may include a database engine for partitioning adata table into column chunks for distributing across multiple storageservers, a storage shared memory for storing the column chunks duringprocessing of semantic operations performed on the column chunks, and astorage services manager for striping column chunks of a partitioneddata table across multiple storage servers.

The database engine may include a loading services module for importingdata into a data table partitioned into column chunks, a query servicesmodule for receiving requests for processing data stored as columnchunks striped across multiple storage servers, a metadata servicesmodule for managing metadata about the column chunks striped across theplurality of storage servers, a transaction services module formaintaining the integrity of the information about semantic operationsperformed on the column chunks, and a storage services proxy module forreceiving storage services requests and sending the requests forexecution by the storage services manager. The storage services managermay include compression services for compressing the column chunksbefore storing to the column chunk data store and transport services forsending one or more compressed or uncompressed column chunks to anotherstorage server.

Advantageously, a data table may be flexibly partitioned into columnchunks using one or more columns as a key with various partitioningmethods, including range partitioning, list partitioning, hashpartitioning, and/or combinations of these partitioning methods. Theremay also be a storage policy for specifying how to partition a datatable for distributing column chunks across multiple servers, includingthe number of column chunks to create. The storage policy may alsospecify the desired level of redundancy of column chunks for recoveryfrom failure of one or more storage servers storing the column chunks.The storage policy may also specify how to assign column chunks toavailable storage servers. There may be a storage policy for each datatable that may be different from the storage policy for another datatable and may specify a different method for partitioning the data tableinto column chunks, a different level of redundancy for recovery fromfailure of one or more servers, and/or a different method fordistributing the column chunks among the multiple storage servers.

The invention may also support recovery from failure of one or morestorage servers in the distributed column chunk data store. When failureof a storage server may be detected, a column chunk may be recreatedfrom a parity column chunk if available. Metadata may additionally beupdated for distributing column chunks from the server experiencingfailure to the remaining storage servers of the column chunk data store.Then the column chunks on the server experiencing failures may berecreated and redistributed to one or more of the remaining storageservers of the column chunk data store. In an embodiment, the parity ofcolumn chunks calculated for supporting a level of redundancy specifiedin a storage policy for recovery from failure of one or more storageservers may be recomputed when the number of storage servers remainingwithout failures may no longer be greater than the number of columnchunks used to compute the parity column chunks.

Other advantages will become apparent from the following detaileddescription when taken in conjunction with the drawings, in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram generally representing a computer system intowhich the present invention may be incorporated;

FIG. 2 is a block diagram generally representing an exemplaryarchitecture of system components for a column chunk data store, inaccordance with an aspect of the present invention;

FIG. 3 is a flowchart generally representing the steps undertaken in oneembodiment for storing column chunks among multiple storage servers inthe column chunk data store, in accordance with an aspect of the presentinvention;

FIG. 4 is a flowchart generally representing the steps undertaken in oneembodiment for partitioning a data table into column chunks, inaccordance with an aspect of the present invention;

FIGS. 5A and 5B are exemplary illustrations generally depicting logicalrepresentations of column chunks of a partitioned data table stripedacross multiple storage servers with parity for recovering from failureof a server, in accordance with an aspect of the present invention;

FIG. 6 is a flowchart generally representing the steps undertaken in oneembodiment for recovery from failure of a storage server in the columnchunk data store, in accordance with an aspect of the present invention;

FIG. 7 is a flowchart generally representing the steps undertaken in oneembodiment for redistributing column chunks from a failed storage serveramong remaining storage servers in the column chunk data store, inaccordance with an aspect of the present invention; and

FIGS. 8A and 8B are exemplary illustrations generally depicting logicalrepresentations of column chunks of a partitioned data table stripedacross multiple storage servers after redistributing column chunks froma failed storage server, in accordance with an aspect of the presentinvention.

DETAILED DESCRIPTION

Exemplary Operating Environment

FIG. 1 illustrates suitable components in an exemplary embodiment of ageneral purpose computing system. The exemplary embodiment is only oneexample of suitable components and is not intended to suggest anylimitation as to the scope of use or functionality of the invention.Neither should the configuration of components be interpreted as havingany dependency or requirement relating to any one or combination ofcomponents illustrated in the exemplary embodiment of a computer system.The invention may be operational with numerous other general purpose orspecial purpose computing system environments or configurations.

The invention may be described in the general context ofcomputer-executable instructions, such as program modules, beingexecuted by a computer. Generally, program modules include routines,programs, objects, components, data structures, and so forth, whichperform particular tasks or implement particular abstract data types.The invention may also be practiced in distributed computingenvironments where tasks are performed by remote processing devices thatare linked through a communications network. In a distributed computingenvironment, program modules may be located in local and/or remotecomputer storage media including memory storage devices.

With reference to FIG. 1, an exemplary system for implementing theinvention may include a general purpose computer system 100. Componentsof the computer system 100 may include, but are not limited to, a CPU orcentral processing unit 102, a system memory 104, and a system bus 120that couples various system components including the system memory 104to the processing unit 102. The system bus 120 may be any of severaltypes of bus structures including a memory bus or memory controller, aperipheral bus, and a local bus using any of a variety of busarchitectures. By way of example, and not limitation, such architecturesinclude Industry Standard Architecture (ISA) bus, Micro ChannelArchitecture (MCA) bus, Enhanced ISA (EISA) bus, Video ElectronicsStandards Association (VESA) local bus, and Peripheral ComponentInterconnect (PCI) bus also known as Mezzanine bus.

The computer system 100 may include a variety of computer-readablemedia. Computer-readable media can be any available media that can beaccessed by the computer system 100 and includes both volatile andnonvolatile media. For example, computer-readable media may includevolatile and nonvolatile computer storage media implemented in anymethod or technology for storage of information such ascomputer-readable instructions, data structures, program modules orother data. Computer storage media includes, but is not limited to, RAM,ROM, EEPROM, flash memory or other memory technology, CD-ROM, digitalversatile disks (DVD) or other optical disk storage, magnetic cassettes,magnetic tape, magnetic disk storage or other magnetic storage devices,or any other medium which can be used to store the desired informationand which can accessed by the computer system 100. Communication mediamay also embodies computer-readable instructions, data structures,program modules or other data in a modulated data signal such as acarrier wave or other transport mechanism and includes any informationdelivery media. The term “modulated data signal” means a signal that hasone or more of its characteristics set or changed in such a manner as toencode information in the signal. For instance, communication mediaincludes wired media such as a wired network or direct-wired connection,and wireless media such as acoustic, RF, infrared and other wirelessmedia.

The system memory 104 includes computer storage media in the form ofvolatile and/or nonvolatile memory such as read only memory (ROM) 106and random access memory (RAM) 110. A basic input/output system 108(BIOS), containing the basic routines that help to transfer informationbetween elements within computer system 100, such as during start-up, istypically stored in ROM 106. Additionally, RAM 110 may contain operatingsystem 112, application programs 114, other executable code 116 andprogram data 118. RAM 110 typically contains data and/or program modulesthat are immediately accessible to and/or presently being operated on byCPU 102.

The computer system 100 may also include other removable/non-removable,volatile/nonvolatile computer storage media. By way of example only,FIG. 1 illustrates a hard disk drive 122 that reads from or writes tonon-removable, nonvolatile magnetic media, and storage device 134 thatmay be an optical disk drive or a magnetic disk drive that reads from orwrites to a removable, a nonvolatile storage medium 144 such as anoptical disk or magnetic disk. Other removable/non-removable,volatile/nonvolatile computer storage media that can be used in theexemplary computer system 100 include, but are not limited to, magnetictape cassettes, flash memory cards, digital versatile disks, digitalvideo tape, solid state RAM, solid state ROM, and the like. The harddisk drive 122 and the storage device 134 may be typically connected tothe system bus 120 through an interface such as storage interface 124.

The drives and their associated computer storage media, discussed aboveand illustrated in FIG. 1, provide storage of computer-readableinstructions, executable code, data structures, program modules andother data for the computer system 100. In FIG. 1, for example, harddisk drive 122 is illustrated as storing operating system 112,application programs 114, other executable code 116 and program data118. A user may enter commands and information into the computer system100 through an input device 140 such as a keyboard and pointing device,commonly referred to as mouse, trackball or touch pad tablet, electronicdigitizer, or a microphone. Other input devices may include a joystick,game pad, satellite dish, scanner, and so forth. These and other inputdevices are often connected to CPU 102 through an input interface 130that is coupled to the system bus, but may be connected by otherinterface and bus structures, such as a parallel port, game port or auniversal serial bus (USB). A display 138 or other type of video devicemay also be connected to the system bus 120 via an interface, such as avideo interface 128. In addition, an output device 142, such as speakersor a printer, may be connected to the system bus 120 through an outputinterface 132 or the like computers.

The computer system 100 may operate in a networked environment using anetwork 136 to one or more remote computers, such as a remote computer146. The remote computer 146 may be a personal computer, a server, arouter, a network PC, a peer device or other common network node, andtypically includes many or all of the elements described above relativeto the computer system 100. The network 136 depicted in FIG. 1 mayinclude a local area network (LAN), a wide area network (WAN), or othertype of network. Such networking environments are commonplace inoffices, enterprise-wide computer networks, intranets and the Internet.In a networked environment, executable code and application programs maybe stored in the remote computer. By way of example, and not limitation,FIG. 1 illustrates remote executable code 148 as residing on remotecomputer 146. It will be appreciated that the network connections shownare exemplary and other means of establishing a communications linkbetween the computers may be used.

Recovery From Failure of a Storage Server in a Distributed Column ChunkData Store

The present invention is generally directed towards a system and methodfor recovery from failure of a storage server in a distributed columnchunk data store. More particularly, the present invention providesmultiple storage servers operably coupled by a network for storingdistributed column chunks of partitioned data tables. Any data table maybe partitioned into column chunks and the column chunks may then bedistributed for storage among multiple storage servers. To do so, a datatable may be flexibly partitioned into column chunks by applying variouspartitioning methods using one or more columns as a key, including rangepartitioning, list partitioning, hash partitioning, and/or combinationsof these partitioning methods. Subsequently, one or more storage serversmay fail in the distributed column chunk data store. When failure of astorage server may be detected, a column chunk may be recreated from aparity column chunk if available. Metadata may additionally be updatedfor distributing column chunks from the server experiencing failure tothe remaining storage servers of the column chunk data store. Then thecolumn chunks on the server experiencing failures may be recreated andredistributed to one or more of the remaining storage servers of thecolumn chunk data store.

As will be seen, the parity of column chunks calculated for supportingthe level of redundancy specified in a storage policy for recovery fromfailure of one or more storage servers may be recomputed when the numberof storage servers remaining without failures may no longer be greaterthan the number of column chunks used to compute the parity columnchunks. As will be understood, the various block diagrams, flow chartsand scenarios described herein are only examples, and there are manyother scenarios to which the present invention will apply.

Turning to FIG. 2 of the drawings, there is shown a block diagramgenerally representing an exemplary architecture of system componentsfor a distributed column chunk data store. Those skilled in the art willappreciate that the functionality implemented within the blocksillustrated in the diagram may be implemented as separate components orthe functionality of several or all of the blocks may be implementedwithin a single component. For example, the functionality for thestorage services manager 226 may be included in the same component asthe database engine 208. Or the functionality of transport services 232may be implemented as a separate component.

As used herein, a column chunk data store may mean a large distributedsystem of operably coupled storage servers, each capable of storingcolumn chunks. In various embodiments, one or more applications 202 maybe operably coupled to one or more storage servers 206 by a network 204.The network 204 may be any type of network such as a local area network(LAN), a wide area network (WAN), or other type of network. In general,an application 202 may be any type of executable software code such as akernel component, an application program, a linked library, an objectwith methods, and so forth. In one embodiment, an application mayexecute on a client computer or computing device, such as computersystem environment 100 of FIG. 1 which may be operably coupled to one ormore storage servers 206 by the network 204. An application 202 mayinclude functionality for querying the column chunk data store toretrieve information for performing various data mining or businessintelligence operations, such as computing segment membership,performing some aggregation of data including summarization, and soforth.

A storage server 206 may be any type of computer system or computingdevice such as computer system environment 100 of FIG. 1. The storageserver may provide services for performing semantic operations on columnchunks such as redistributing data, replacing storage, and/or addingstorage and may use lower-level file system services in carrying outthese semantic operations. A storage server 206 may include a databaseengine 208 storage shared memory 222, and a storage services manager226. Each of these modules may also be any type of executable softwarecode such as a kernel component, an application program, a linkedlibrary, an object with methods, or other type of executable softwarecode.

The database engine 208 may be responsible, in general, forcommunicating with an application 202, communicating with the storageserver to satisfy client requests, accessing the column chunk datastore, and communicating with the storage services manager 226 forexecution of storage operations, including accessing column chunks 224in storage shared memory 220. The database engine 208 may include loadservices 210, query services 212, metadata services 214, transactionservices 216 and a storage services proxy 218. Load services 210 may beused for importing data into the data tables. Query services 212 mayprocess received queries by retrieving the data from the storageservices manager 226 and processing the retrieved data. The loadservices 210 and query services 212 may communicate with the metadataservices 214 and transaction services 216 using a communicationmechanism such as interprocess communication. Each of these services mayin turn communicate with the storage services proxy 218 to requestservices such as retrieving and loading column chunks into storageshared memory 220. The storage services proxy 218 may receive storageread and write requests and pass the requests off to the storageservices manager 226 to execute the request.

The metadata services 214 may provide services for the configuration ofthe storage servers and may manage metadata for the database engine andthe column chunk data store. The metadata may include, for example, datatables that reflect the current state of the system including the nameof each server configured in the system, the load on each server, thebandwidth between servers, and many other variables maintained in thedata tables. There may be dynamically updated tables and static tablesof data. Static tables of data may include configuration tables, thedefined logical tables, policies that may apply for partitioning thedata table and storage distribution, and so forth. Some tables, such asconfiguration tables, may be generated dynamically by the system basedupon system configuration. The metadata services 214 may includeservices to dynamically update metadata, such as configuration tables.In addition, metadata services 214 may include services to add or updatefixed metadata such as adding new logical data table definitions orupdating an existing logical data table definition.

The transaction services 216 may be responsible for maintaining activetransactions in the system and may provide various services such asidentifying and loading the appropriate version of column chunks. Thetransaction services 216 can also notify metadata services to update orcommit metadata relating to a specific transaction. Generally, atransaction may include semantic operations that modify the system orthat may be performed on data, including data loading, dataoptimization, data retrieval, updating existing data table, creating newtables, modifying the data schema, creating a new storage policy,partitioning data tables, recording the column chunk distribution instorage servers, and so forth. For each transaction such asincrementally updating a data table, there may be an indication of astart of a transaction and end of transaction when the update of thedata table completes. Other examples of transactions may be executing aquery, including generating intermediate data tables or other datatables, or optimizing storage of column chunks. To do so, the queryservices may use transaction services to process a query and the storageservices manager may use transactions services while optimizing columnchunk storage.

The storage shared memory 220 of the storage server 206 may include lowlevel metadata 222 and column chunks 224. The low level metadata mayinclude information about physical storage, such as the file name andserver name where a column chunk may be located, what the compressedsize of a column chunk may be, what the uncompressed size of a columnchunk may be, what the checksum on a column chunk may be for verifyingthat the column chunk is not corrupted on the disk storage, and soforth. The storage services manager 226 may generate low level metadata222 by using the metadata such as policies, server configurations,resources available in metadata to generate physical storage for columnchunks.

The storage services manager 226 may include a local storage servicesmanager 228 that may provide compression services 230 and transportservices 232. The compression services 230 may perform data domaincompression and decompression of column chunks. For instance, datadomain compression may be performed before storing the column chunks instorage and data domain decompression may be performed upon retrievingthe column chunks from storage. Transports services 232 may provideservices to transfer column chunks between servers. In one embodiment, alow level protocol may be employed upon a TCP/IP protocol stack forsending and receiving column chunks.

There are many applications which may use the present invention forstoring large volumes of detailed data over long periods of time. Datamining, segmentation and business intelligence applications are examplesamong these many applications. FIG. 3 presents a flowchart generallyrepresenting the steps undertaken in one embodiment for storing columnchunks among multiple storage servers in the column chunk data store. Atstep 302, a data table may be partitioned into column chunks. As usedherein, a column chunk may mean a column of a data table partitionedusing one or more columns as a key. Any type of data table may bepartitioned into column chunks. For instance, a large fact tablecapturing transactions of users logging into a website may bepartitioned into column chunks. In one embodiment, the data table may bepartitioned into column chunks by performing column-wise partitioningwhereby a partition may be specified by a set of columns. In anotherembodiment, a combination of some data table partitioning technique andcolumn-wise partitioning may be performed. In this embodiment, the datatable may be first partitioned into several data tables and thencolumn-wise partitioning may be performed on the resulting data tablesto create column chunks. To do so, those skilled in the art willappreciate that a data table may be partitioned into column chunks usingany number of partitioning techniques such as range partitioning byspecifying a range of value for a partitioning key, list partitioning byspecifying a list of values for a partitioning key, hash partitioning byapplying hashing to a partitioning key, combinations of thesepartitioning techniques, and other partitioning techniques known tothose skilled in the art.

Once the data table may be partitioned into column chunks, the storageserver may distribute the column chunks among multiple storage serversat step 304. For example, the column chunks of the data table may bestriped across multiple storage servers. In one embodiment, each columnchunk of the data table may be assigned to an available storage serverusing any assignment method including round robin order. In variousembodiments, column chunks of a data table may be striped acrossmultiple storage servers. As used herein, column chunk striping meansstriping column chunks of a data table across multiple storage servers.Any level of redundancy may be implemented in distributing the columnchunks for recovery of one or more failed servers. For example, columnchunk parity may be calculated and stored to enable recovery fromfailure of one server. In an embodiment, a bitwise XOR operation may beperformed on two column chunks to create a parity column chunk.Additional bitwise XOR operations may be performed with a parity columnchunk and another binary representation of a column chunk to compute aparity column chunk for three column chunks. The resulting parity columnchunk may then be assigned to an available server that does not storeone of the three column chunks used to make the parity column chunk. Inthis way, any number of parity column chunks may be calculated andassigned to storage servers for recovery from failure of one or morestorage servers. It should be noted that prior to performing a bitwiseXOR operation on two column chunks of unequal length, the shorter columnchunk may be padded with 0's until it become of equal length with theother column chunk.

Once the distribution of column chunks among the multiple storageservers may be determined, the column chunks may be stored on theirassigned servers at step 306. After the column chunks have been stored,processing may be finished for storing column chunks among multiplestorage servers in the column chunk data store.

FIG. 4 presents a flowchart generally representing the steps undertakenin one embodiment for partitioning a data table into column chunks. Atstep 402, a policy for partitioning the data table into column chunksmay be accessed. For example, there may be a policy stored as part ofthe metadata that may specify how the data table may be partitioned intocolumn chunks and how the column chunks may be distributed amongmultiple storage servers in the column chunk data store. In oneembodiment, the policy may specify the number of partitions into which acolumn should be divided. In various embodiments, the policy may specifythe degree of redundancy of the column chunks for recovery upon failureof one or more storage servers.

Any policy for partitioning the data table may then be applied at step404 to create the column chunks. In an embodiment, partitioning may beperformed on the data table by first partitioning the data table intomultiple tables using range partitioning and then partitioning each ofthe multiple tables by applying column-wise partitioning. In variousother embodiments, list partitioning, hash partitioning, or combinationsof list, hash, and/or range partitioning may be applied to partition thedata table into multiple tables and then column wise partitioning may besubsequently applied to each of the multiple data tables.

Once the column chunks may be created, then data domain compression maybe applied to the column chunks at step 406. Data domain compression asused herein may mean applying a compression scheme designed to compressa specific data type. Given that values in a column of a column chunkmay usually be the same data type and/or part of a specific data domain,partitioning a data table into column chunks may advantageously allowdata in the column chunks to be compressed using a specific domain typecompression scheme. For example, if a column of a column chunk may storea date that falls within a narrow range, such as between Jan. 1, 2000and Dec. 31, 2010, the date field may be represented using the number ofdays since Jan. 1, 2000 rather than using a generic date representation.As another example, consider an address that may typically be stored asa string that may not compress well. By decomposing the address fieldinto several subfields, such as street number, street name, city, state,and zip, each subfield may be represented as a separate sub-columnhaving a specific data type that may compress well. As yet anotherexample, consider an argument list of key-value pairs that may also betypically stored as a string that may not compress well. By decomposingthe key-value pairs into separate column chunks, each column chunk mayrepresent values having a specific data type that may compress well.Such compression may be performed using range-based compression ofnumeric values, decomposing a column chunk including sub-fields intoseparate column chunks, decomposing a column chunk including key-valuepairs into separate column chunks, and so forth. After domain specificcompression may be applied to the column chunks, processing forpartitioning a data table into column chunks may be finished.

FIGS. 5A and 5B present exemplary illustrations generally depictinglogical representations of column chunks of a partitioned data tablestriped across multiple storage servers with parity for recovering fromfailure of a server. There may be any number of storage servers, such asstorage servers S1 502 and S2 506 illustrated in FIG. 5A, and S3 510 andS4 514 illustrated in FIG. 5B. A data table T1 may be first partitionedby date to create two data table such as T1.D1 and T1.D2, and thenhashing may be applied to each of these data table to create columnchunks. The storage policy may specify a redundancy level for recoveryfrom failure of a server. There may also be a distribution policy suchas column chunk striping specified in the storage policy. FIGS. 5A and5B illustrate an embodiment of column chunk striping with redundancyacross multiple servers in round robin order. For instance, hashing mayproduce 12 hashes, which may be represented as H01 through H12.Considering that data table T1.D1 may have four columns, C1 through C4,there may be 48 column chunks created with four column chunks in eachhash bucket, which may be represented as T1.D1.H01.C1, T1.D1.H01.C2,T1.D1.H01.C3, T1.D1.H01.C4, T1.D1.H02.C1 . . . T1.D1.H12.C4 asillustrated in FIGS. 5A and 5B. Additionally, parity may be calculatedby performing a bitwise XOR operation for combinations of column chunkssuch asT1.D1.H04.C1ˆT1.D1.H05.C1ˆ T1.D1.H06.C1,T1.D1.H04.C2ˆT1.D1.H05.C2ˆ T1.D1.H06.C2,T1.D1.H04.C3ˆT1.D1.H05.C3ˆ T1.D1.H06.C3, andT1.D1.H04.C4ˆT1.D1.H05.C4ˆ T1.D1.H06.C4.

Column chunks, T1.D1.H01.C1 through T1.D1.H01.C4, may be assigned to thefirst storage server, S1 502, and stored in file system 504.Additionally, parity of column chunks, T1.D1.H04.C1ˆT1.D1.H05.C1ˆT1.D1.H06.C1 through T1.D1.H04.C4ˆT1.D1.H05.C4ˆ T1.D1.H06.C4, may alsobe assigned to the first storage server, S1 502, and stored in filesystem 504. Column chunks, T1.D1.H02.C1 through T1.D1.H02.C4 andT1.D1.H04.C1 through T1.D1.H04.C4, may be assigned to the second storageserver, S2 506, and stored in file system 508. Additionally, parity ofcolumn chunks, T1.D1.H07.C1ˆT1.D1.H08.C1ˆ T1.D1.H09.C1 throughT1.D1.H07.C4ˆT1.D1.H08.C4ˆ T1.D1.H09.C4, may also be assigned to thesecond storage server, S2 506, and stored in file system 508. Columnchunks, T1.D1.H03.C1 through T1.D1.H03.C4 and T1.D1.H05.C1 throughT1.D1.H05.C4, may be assigned to the third storage server, S3 510, andstored in file system 512. Additionally, parity of column chunks,T1.D1.H10.C1ˆT1.D1.H11.C1ˆ T1.D1.H12.C1 throughT1.D1.H10.C4ˆT1.D1.H11.C4ˆ T1.D1.H12.C4, may also be assigned to thethird storage server, S3 510, and stored in file system 512. Columnchunks, T1.D1.H06.C1 through T1.D1.H06.C4, may be assigned to the fourthstorage server, S4 514, and stored in file system 516. Additionally,parity of column chunks, T1.D1.H01.C1ˆT1.D1.H02.C1ˆ T1.D1.H03.C1 throughT1.D1.H01.C4ˆT1.D1.H02.C4ˆ T1.D1.H03.C4, may also be assigned to thefourth storage server, S4 514, and stored in file system 516.

Then column chunks T1.D1.H07.C1 through T1.D1.H07.C4 may be assigned tothe third storage server, S3 510, and stored in file system 512. Next,column chunks T1.D1.H08.C1 through T1.D1.H08.C4 and T1.D1.H10.C1 throughT1.D1.H10.C4 may be assigned to the fourth storage server, S4 514, andstored in file system 516. Column chunks T1.D1.H09.C1 throughT1.D1.H09.C4 and T1.D1.H11.C1 through T1.D1.H11.C4 may be assigned tothe first storage server, S1 502, and stored in file system 504.Finally, column chunks T1.D1.H12.C1 through T1.D1.H12.C4 may be assignedto the second storage server, S2 506, and stored in file system 508.

Similarly, there may be 48 column chunks created for data table T1.D2with four column chunks in each of 12 hash buckets, which may berepresented as T1.D2.H01.C1, T1.D2.H01.C2, T1.D2.H01.C3, T1.D2.H01.C4,T1.D2.H02.C1 . . . T1.D2.H12.C4. These 48 column chunks may likewise bedistributed across multiple servers using column chunk striping withredundancy in round robin order as illustrated in FIGS. 5A and 5B.

After the data tables may be partitioned, distributed and stored in thecolumn chunks data store, one or more storage servers may experience afailure and consequently may not be able to service a request toretrieve a column chunk. FIG. 6 presents a flowchart generallyrepresenting the steps undertaken in one embodiment for recovery fromfailure of a storage server in the column chunk data store. At step 602,a request to retrieve a column chunk may be sent to a storage server inthe column chunk data store. For example, the database engine may send arequest to storage server S4 to retrieve column chunk T1.D2.H06.C1. Atstep 604, storage server failure may be detected. In an embodiment, thedatabase engine may fail to receive a response to a request to retrievea column chunk within a specified time period. Alternatively, thedatabase engine may receive a column chunk in response to the request,but the checksum for the column chunk may fail to match the checksumstored for verifying that the column chunk is not corrupted on the diskstorage. Upon detecting that there may be a storage server failure, itmay then be determined at step 606 whether a parity column chunkgenerated using the column chunk requested may be available. Forinstance, storage server S1 may store parity column chunkT1.D1.H04.C1ˆT1.D1.H05.C1ˆ T1.D1.H06.C1. In an embodiment, there may bea location for the parity column chunk stored along with the checksumfor each column chunk stored in the metadata. In another embodiment,there may be map generated of column chunks used to create a paritycolumn chunk for each data table load. In any case, if there may not bea parity column chunk available, then an indication may be returned atstep 616 that the request for the column chunk failed and processing maybe finished. Otherwise, the requested column chunk may be recreated fromthe available parity column chunk that was generated previously usingthe requested column chunk. To do so, each of the column chunks otherthan the requested column chunk that were used to generate the paritycolumn chunk may be retrieved and a bitwise XOR operation between theparity column chunk and each of the column chunks retrieved may beiteratively performed in turn to recreate the requested column chunk.For example, a bitwise XOR operation may be performed between paritycolumn chunk T1.D1.H04.C1ˆT1.D1.H05.C1ˆ T1.D1.H06.C1 and T1.D1.H04.C1retrieved from storage server S2, and then another bitwise XOR operationmay be performed between the result of that first operation andT1.D1.H05.C1 retrieved from storage server S3 to recreate column chunkT1.D1.H06.C1. The column chunk recreated may be returned at step 610 tothe requester. In various embodiments, the column chunk recreated may bestored on a non-failing storage server.

At step 612, it may be determined whether to send an alert to indicatedegraded system performance. In an embodiment, it may be determined tosend such an alert if the number of recreated column chunks may exceed apredefined threshold. In another embodiment, it may be determinedwhether to send an alert if the retrieval performance measured by anumber of factors, including the number of column chunks created, mayexceed a predefined threshold. An alert may then be sent at step 614 ifit is determined to send an alert. Otherwise, it may be determined atstep 618 whether to redistribute the column chunks stored on the storageserver experiencing failure when requested to retrieve column chunks.For example, it may be determined to redistribute the column chunksstored on the storage server if the storage server may be experiencingfailure in retrieving more than 20% of the column chunks stored on thestorage server. At step 620, the column chunks on the storage serverexperiencing failure may be redistributed to one or more other storageservers in the column chunk data store. In an embodiment, the columnchunks may be redistributed as each column chunk may be recreated inresponse to a request that failed to retrieve the column chunk. Afterthe column chunks may be redistributed from the storage serverexperiencing failures, processing may be finished for recovery fromfailure of a storage server in the column chunk data store.

FIG. 7 presents a flowchart generally representing the steps undertakenin one embodiment for redistributing column chunks from a failed storageserver among remaining storage servers in the column chunk data store.At step 702, metadata may be updated for distributing column chunks froma failed storage server among the remaining storage servers. In anembodiment, a storage policy that may specify assigning column chunks tothe failed storage server may be updated by removing that storage serverfrom the list of storage servers to be used for storing column chunks.For instance, after detecting that storage server S4 may experiencefailures, the storage policy for data table T1 and the storage policyfor data table T2 may be updated to specify distributing the columnchunks across servers S1 through S3, instead of distributing the columnchunks across servers S1 through S4 as may be previously specified. Inaddition to specifying how column chunks may be distributed amongmultiple storage servers in the column chunk data store, a storagepolicy may also specify the level of redundancy of the column chunks forrecovery upon failure of one or more storage servers. For example, thestorage policy may specify a level of redundancy for recovery fromfailure of one server in the column chunk data store and parity ofcolumn chunks may be computed using three column chunks for the columnchunks stored in the column chunk data store.

Accordingly, it may be determined at step 704 whether any level ofredundancy has been specified in the storage policy. If so, then it maybe determined at step 706 whether to recompute the parity of columnchunks to provide the level of redundancy specified in the storagepolicy that may be supported by the remaining storage servers afterfailure of a storage server. For instance, the number of column chunksused to compute a parity column chunk may be one less than the number ofservers used to store the column chunks. If the number of column chunksused to compute the existing parity column chunks is greater than oneless than the number of remaining storage servers that may be used tostore the column chunks, then it may be determined to recompute theparity of column chunks. If it may be determined to recompute the parityof column chunks at step 706, then the parity of the column chunks maybe calculated at step 708 for the level of redundancy specified in thestorage policy. In an embodiment, the number of column chunks used tocompute the parity column chunks may be one less than the number ofremaining storage servers that may be used to store the column chunks.Upon calculating the parity column chunks at step 708, the storagepolicy may be updated at step 710 to indicate the number of columnchunks used to compute parity to achieve the level of redundancyspecified.

Once the storage policy may be updated at step 710 or if it may bedetermined that a level of redundancy may not be specified by the policyat step 704 or if it may be determined that the parity of column chunksshould not be recomputed at step 706, then the column chunks, includingany parity column chunks previously created, may be assigned to storageservers at step 712 according to the storage policy. For instance, ifthe storage policy may specify redundancy to recover from the failure ofa server, then the column chunks and parity column chunks may beassigned as illustrated below in FIGS. 8A and 8B. After the columnchunks and any parity column chunks may be assigned to storage servers,the column chunks may be stored on the assigned storage servers at step714. When the column chunks may be stored on the assigned storageservers, processing for redistributing column chunks from a failedstorage server among remaining storage servers in the column chunk datastore may be finished.

FIGS. 8A and 8B present exemplary illustrations generally depictinglogical representations of column chunks of a partitioned data tablestriped across multiple storage servers after redistributing columnchunks from a failed storage server. After data table T1 may bepartitioned, distributed and stored across storage servers S1 502through S4 514 as illustrated in FIGS. 5A and 5B, a storage server, suchas storage server S4, may experience failures in responding to requeststo retrieve column chunks. The metadata for data table T1 and data tableT2 may be updated to specify distributing the column chunks acrossservers S1 through S3, instead of distributing the column chunks acrossservers S1 through S4 as may have been previously specified.Accordingly, column chunks from partitioned data tables T1.D1 and T1.D2may then be redistributed among the multiple storage servers asspecified by the storage policy in the updated metadata. The storagepolicy may specify a level of redundancy of the column chunks forrecovery upon failure of one storage server. Considering that there maybe sufficient storage servers remaining without failure to support thelevel of redundancy specified, the level of redundancy may be providedby recalculating the parity for the column chunks and thenredistributing the column chunks so that a parity column chunk and anycolumn chunk used to compute that parity column chunk may not be storedon the same storage server. Since there may be three servers availablefor storing the column chunks from the failed storage server, paritycolumn chunks may be recalculated by performing a bitwise XOR operationon two column chunks to create a parity column chunk instead of usingthree column chunks as done previously when there were four serversavailable. FIGS. 8A and 8B may illustrate an embodiment ofredistributing the column chunks from partitioned data tables T1.D1 andT1.D2 so that these column chunks may be striped in round robin orderwith redundancy for recovery of a failed server across storage serversS1 through S3.

First of all, the column chunks created for partitioned data table T1.D1and parity column chunks created may be redistributed so that thesecolumn chunks may be striped in round robin order across storage serversS1 through S3. Specifically, column chunks T1.D1.H01.C1 throughT1.D1.H01.C4, T1.D1.H06.C1 through T1.D1.H06.C4, T1.D1.H07.C1 throughT1.D1.H07.C4, T1.D1.H12.C1 through T1.D1.H12.C4, and parity columnchunks T1.D1.H03.C1ˆT1.D1.H04.C1 through T1.D1.H03.C4ˆT1.D1.H04.C4 andT1.D1.H09.C1ˆT1.D1.H10.C1 through T1.D1.H09.C4ˆT1.D1.H10.C4 may beassigned to the first storage server, S1 502, and stored in file system504. Column chunks T1.D1.H02.C1 through T1.D1.H02.C4, T1.D1.H03.C1through T1.D1.H03.C4, T1.D1.H08.C1 through T1.D1.H08.C4, T1.D1.H09.C1through T1.D1.H09.C4, and parity column chunks T1.D1.H05.C1ˆT1.D1.H06.C1through T1.D1.H05.C4ˆT1.D1.H06.C4 and T1.D1.H11.C1ˆT1.D1.H12.C1 throughT1.D1.H11.C4ˆT1.D1.H12.C4 may be assigned to the second storage server,S2 506, and stored in file system 508. And column chunks T1.D1.H04.C1through T1.D1.H04.C4, T1.D1.H05.C1 through T1.D1.H05.C4, T1.D1.H10.C1through T1.D1.H10.C4, T1.D1.H11.C1 through T1.D1.H11.C4, and paritycolumn chunks T1.D1.H01.C1ˆT1.D1.H02.C1 throughT1.D1.H01.C4ˆT1.D1.H02.C4 and T1.D1.H07.C1ˆT1.D1.H08.C1 throughT1.D1.H07.C4ˆT1.D1.H08.C4 may be assigned to the third storage server,S3 510, and stored in file system 512.

Similarly, the column chunks created for partitioned data table T1.D2and parity column chunks created may be redistributed so that thesecolumn chunks may be striped in round robin order across storage serversS1 through S3. For example, column chunks T1.D2.H01.C1 throughT1.D2.H01.C4, T1.D2.H06.C1 through T1.D2.H06.C4, T1.D2.H07.C1 throughT1.D2.H07.C4, T1.D2.H12.C1 through T1.D2.H12.C4, and parity columnchunks T1.D2.H03.C1ˆT1.D2.H04.C1 through T1.D2.H03.C4ˆT1.D2.H04.C4 andT1.D2.H09.C1{circumflex over (0 )}T1.D2.H10.C1 throughT1.D2.H09.C4ˆT1.D2.H10.C4 may be assigned to the first storage server,S1 502, and stored in file system 504. Column chunks T1.D2.H02.C1through T1.D2.H02.C4, T1.D2.H03.C1 through T1.D2.H03.C4, T1.D2.H08.C1through T1.D2.H08.C4, T1.D2.H09.C1 through T1.D2.H09.C4, and paritycolumn chunks T1.D2.H05.C1ˆT1.D2.H06.C1 throughT1.D2.H05.C4ˆT1.D2.H06.C4 and T1.D2.H11.C1ˆT1.D2.H12.C1 throughT1.D2.H11.C4ˆT1.D2.H12.C4 may be assigned to the second storage server,S2 506, and stored in file system 508. And column chunks T1.D2.H04.C1through T1.D2.H04.C4, T1.D2.H05.C1 through T1.D2.H05.C4, T1.D2.H10.C1through T1.D2.H10.C4, T1.D2.H11.C1 through T1.D2.H11.C4, and paritycolumn chunks T1.D2.H01.C1ˆT1.D2.H02.C1 throughT1.D2.H01.C4ˆT1.D2.H02.C4 and T1.D2.H07.C1ˆT1.D2.H08.C1 throughT1.D2.H07.C4ˆT1.D2.H08.C4 may be assigned to the third storage server,S3 510, and stored in file system 512.

To redistribute the column chunks for partitioned data tables T1.D1 andT1.D2, column chunks may be moved from storage servers S1 through S3 asillustrated in FIGS. 5A and 5B to storage servers S1 through S3 asillustrated in FIGS. 8A and 8B. For example, T1.D1.H03.C1 throughT1.D1.H03.C4 and T1.D2.H03.C1 through T1.D2.H03.C4 may be moved fromstorage server S3 as illustrated in FIG. 5B to storage server S2 asillustrated in FIG. 8A. By so moving column chunks for partitioned datatables T1.D1 and T1.D2, the column chunks previously stored on serversS1 through S3 may be redistributed so that they may be striped acrossservers S1 through S3 along with the recreated column chunks previouslystored on storage server S4 and the new parity column chunks created.Those skilled in the art will appreciate that these column chunks mayalso be redistributed differently in various other embodiments,including embodiments where a different number of storage servers havefailed.

Thus the present invention may flexibly support recovery from failure ofa storage server in a distributed column chunk data store. By changingthe storage policy for column chunks of partitioned data tables, thecolumn chunks may be redistributed accordingly among the remainingstorage servers without failure. Moreover, the same level of redundancymay be achieved if there are a sufficient number of remaining serverswithout failure by recomputing the parity of column chunks. As long asthere is sufficient storage available for storing additional paritycolumn chunks on the remaining storage servers, recomputing the parityof column chunks may advantageously support providing the same level ofredundancy in the event a storage server may fail.

As can be seen from the foregoing detailed description, the presentinvention provides an improved system and method for recovery fromfailure of a storage server in a distributed column chunk data store.Any data table may be flexibly partitioned into column chunks byapplying various partitioning methods using one or more columns as akey, including range partitioning, list partitioning, hash partitioning,and/or combinations of these partitioning methods. Furthermore, domainspecific compression may be applied to a column chunk to reduce storagerequirements of column chunks and decrease transmission delays fortransferring column chunks between storage servers. Storage servers maythen experience failure in the distributed column chunk data store andcolumn chunks may be flexibly recreated and redistributed among theremaining storage servers. Such a system and method support storingdetailed data needed by data mining, segmentation and businessintelligence applications over long periods of time. As a result, thesystem and method provide significant advantages and benefits needed incontemporary computing, and more particularly in data mining andbusiness intelligence applications.

While the invention is susceptible to various modifications andalternative constructions, certain illustrated embodiments thereof areshown in the drawings and have been described above in detail. It shouldbe understood, however, that there is no intention to limit theinvention to the specific forms disclosed, but on the contrary, theintention is to cover all modifications, alternative constructions, andequivalents falling within the spirit and scope of the invention.

1. A computer-implemented method for recovery from failure of a storageserver in a distributed system, comprising: detecting failure of astorage server operably coupled to one or more storage servers storingcolumn chunks of a partitioned data table; retrieving a parity columnchunk stored on a storage server of the one or more storage servers; andrecreating a column chunk from the parity column chunk stored on thestorage server of the one or more storage servers.
 2. The method ofclaim 1 further comprising determining whether the parity column chunkfor recreating the column chunk may be available on the storage serverof the one or more storage servers.
 3. The method of claim 1 furthercomprising receiving a request for retrieving the column chunk from thestorage server.
 4. The method of claim 1 further comprising returningthe recreated column chunk to a sender of the request for retrieving thecolumn chunk.
 5. The method of claim 1 further comprising determiningwhether to send an alert to indicate degraded system performance.
 6. Themethod of claim 1 further comprising sending an alert to indicatedegraded system performance.
 7. The method of claim 1 further comprisingdetermining whether to redistribute column chunks from the storageserver to the one or more storage servers.
 8. The method of claim 1further comprising redistributing the column chunks from the storageserver to the one or more storage servers.
 9. A computer-readable mediumhaving computer-executable instructions for performing the method ofclaim
 1. 10. A computer-implemented method for recovery from failure ofa storage server in a distributed system, comprising: detecting failureof a storage server operably coupled to one or more storage serversstoring column chunks of a partitioned data table; updating metadata forredistributing column chunks stored on the storage server among the oneor more storage servers; recreating at least one column chunk from aparity column chunk stored on a first storage server of the one or morestorage servers; and storing the at least one recreated column chunk ona second storage server of the one or more storage servers.
 11. Themethod of claim 10 further comprising determining whether to recomputeparity of the column chunks of the partitioned data table.
 12. Themethod of claim 10 further comprising computing new parity column chunksfor the column chunks.
 13. The method of claim 10 further comprisingassigning a storage server for storing the at least one column chunkrecreated.
 14. The method of claim 12 further comprising assigning adifferent storage server for storing a new parity column chunk than thestorage servers assigned for storing the column chunks used to createthe new parity column chunk.
 15. A computer-readable medium havingcomputer-executable instructions for performing the method of claim 10.16. A distributed computer system for storing data tables, comprising:means for detecting failure of a storage server operably coupled to oneor more storage servers storing column chunks of a partitioned a datatable; means for recreating at least one column chunk from a paritycolumn chunk stored on a storage server of the one or more storageservers; and means for redistributing some of the column chunks amongthe storage server and the one or more storage servers.
 17. Thedistributed computer system of claim 16 further comprising means fordetermining whether to recompute parity of the column chunks.
 18. Thedistributed computer system of claim 16 further comprising means forrecomputing parity of the column chunks.
 19. The distributed computersystem of claim 18 further comprising means for storing a recomputedparity column chunk on a different storage server than the storageservers storing the column chunks used to compute the recomputed paritycolumn chunk.
 20. The distributed computer system of claim 15 whereinmeans for redistributing some of the column chunks among the storageserver and the one or more storage servers comprises means for movingcolumn chunks stored on the storage server to the one or more storageservers.